package com.maixy.studyonlineapi.utils;


import java.math.BigDecimal;
import java.util.Map;


/**
 * 数据类型转换工具类
 *
 * @author HuangLinWei
 * @since 2018/8/17
 */
public class DataTypeUtil {

    private static final BigDecimal HUNDRED = BigDecimal.valueOf(100);

    private DataTypeUtil() {

    }

    /**
     * 转换成Long,转换失败时返回0L
     *
     * @param o 参数
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Long getLong(Object o) {
        return getLong(o, 0L);
    }

    /**
     * 转换成Long,转换失败时返回defaultValue
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Long getLong(Object o, Long defaultValue) {
        if (o == null) {
            return defaultValue;
        }
        try {
            return Long.parseLong(o.toString());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 转换成Float类型,默认值为0
     *
     * @param o 参数
     * @return java.lang.Float
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Float getFloat(Object o) {
        return getFloat(o, 0f);
    }

    /**
     * 从map获取Float类型
     *
     * @param map          数据源
     * @param key          键
     * @param defaultValue 默认值
     * @return java.lang.Float
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Float getFloat(Map<String, Object> map, String key, Float defaultValue) {
        return getFloat(map.get(key), defaultValue);
    }

    /**
     * 转换成Float,转换失败时返回defaultValue
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return java.lang.Float
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Float getFloat(Object o, Float defaultValue) {
        if (o == null) {
            return defaultValue;
        }
        try {
            return Float.parseFloat(o.toString());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 转换成Double,默认值为0
     *
     * @param o 参数
     * @return java.lang.Double
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Double getDouble(Object o) {
        return getDouble(o, 0d);
    }

    /**
     * 从map中获取一个Double型数据,默认值为0
     *
     * @param map 数据源
     * @param key 键
     * @return java.lang.Double
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Double getDouble(Map<String, Object> map, String key) {
        return getDouble(map.get(key), 0D);
    }

    /**
     * 转换成Double,转换失败返回默认值
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return java.lang.Double
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Double getDouble(Object o, Double defaultValue) {
        if (o == null) {
            return defaultValue;
        }
        try {
            return Double.parseDouble(o.toString());
        } catch (Exception e) {
            return defaultValue;
        }
    }


    /**
     * 从map中获取一个Long型数据,默认值为0
     *
     * @param map 数据源
     * @param key 键
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Long getLong(Map<String, Object> map, String key) {
        return getLong(map.get(key), 0L);
    }

    /**
     * 从map中获取一个Long型数据
     *
     * @param map          数据源
     * @param key          键
     * @param defaultValue 默认值
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Long getLong(Map<String, Object> map, String key, Long defaultValue) {
        return getLong(map.get(key), defaultValue);
    }

    /**
     * 转换Integer,默认值为0
     *
     * @param o 参数
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Integer getInteger(Object o) {
        return getInteger(o, 0);
    }

    /**
     * 转换Integer,转换失败返回默认值
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Integer getInteger(Object o, Integer defaultValue) {
        if (o == null) {
            return defaultValue;
        }
        try {
            return Integer.parseInt(o.toString());
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 从map中获取一个Integer型数据,默认值为0
     *
     * @param map 数据源
     * @param key 键
     * @return java.lang.Integer
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Integer getInteger(Map<String, Object> map, String key) {
        return getInteger(map.get(key), 0);
    }

    /**
     * 从map中获取一个Integer型数据
     *
     * @param map          数据源
     * @param key          键
     * @param defaultValue 默认值
     * @return java.lang.Integer
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static Integer getInteger(Map<String, Object> map, String key, Integer defaultValue) {
        return getInteger(map.get(key), defaultValue);
    }

    /**
     * 从map中获取一个布尔型数据,默认值为false
     *
     * @param map 数据源
     * @param key 键
     * @return boolean
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static boolean getBoolean(Map<String, Object> map, String key) {
        return getBoolean(map.get(key), false);
    }

    /**
     * 从map中获取一个布尔型数据,转换失败返回默认值
     *
     * @param map          数据源
     * @param key          键
     * @param defaultValue 默认值
     * @return boolean
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static boolean getBoolean(Map<String, Object> map, String key, boolean defaultValue) {
        return getBoolean(map.get(key), defaultValue);
    }

    /**
     * 转换布尔值,默认返回false
     *
     * @param o 参数
     * @return boolean
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static boolean getBoolean(Object o) {
        return getBoolean(o, false);
    }

    /**
     * 转换布尔值,转换失败返回默认值
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return boolean
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static boolean getBoolean(Object o, boolean defaultValue) {

        if (o instanceof Boolean) {
            return (boolean) o;
        }

        String s = getStr(o);
        if ("".equals(s)) {
            return defaultValue;
        }
        String trueNum = "1";
        if (trueNum.equals(s)) {
            return true;
        }
        String falseNum = "0";
        if (falseNum.equals(s)) {
            return false;
        }
        String trueString = "true";
        if (trueString.equals(s)) {
            return true;
        }
        String falseString = "false";
        if (falseString.equals(s)) {
            return false;
        }

        return defaultValue;
    }


    /**
     * 转换成字符串,转换失败时返回空字符串
     *
     * @param o 参数
     * @return java.lang.String
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static String getStr(Object o) {
        return getStr(o, "");
    }


    /**
     * 转换成字符串,转换失败时返回defaultValue
     *
     * @param o            参数
     * @param defaultValue 默认值
     * @return java.lang.String
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static String getStr(Object o, String defaultValue) {
        if (o == null) {
            return defaultValue;
        }

        if (o instanceof String) {
            if ("".equals(o)) {
                return defaultValue;
            }

            return (String) o;
        }

        return o.toString();
    }


    /**
     * 从map中获取一个字符串,默认值为空字符串
     *
     * @param map 数据源
     * @param key 键
     * @return java.lang.String
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static String getStr(Map<String, Object> map, String key) {
        return getStr(map, key, "");
    }


    /**
     * 从map中获取一个字符串,失败返回默认值
     *
     * @param map          数据源
     * @param key          键
     * @param defaultValue 默认值
     * @return java.lang.String
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static String getStr(Map<String, Object> map, String key, String defaultValue) {
        if (map == null) {
            return null;
        }
        return getStr(map.get(key), defaultValue);
    }

    /**
     * 将以分为单位的整数转换成以元为单位的数值
     * 不进行四舍五入 不截取小数
     * @param money 单位为分
     * @return 元
     */
    public static String fen2yuan(Integer money) {
        return new BigDecimal(money).divide(HUNDRED).toPlainString();
    }

    /**
     * 将以分为单位的整数转换成以元为单位的数值
     *
     * @param money 人民币
     * @return java.lang.String
     * @author HuangLinWei
     * @since 2018/8/17
     */
    public static String cent2yuan(Integer money) {
        return new BigDecimal(money).divide(HUNDRED, BigDecimal.ROUND_DOWN).toPlainString();
    }

    /**
     * 长整型相加
     *
     * @param augend1 加数
     * @param augend2 加数
     * @return java.lang.Long
     * @author HuangLinWei
     * @since 2018/11/7
     */
    public static Long add(Long augend1, Long augend2) {
        if (augend1 == null && augend2 == null) {
            return 0L;
        }
        if (augend1 == null || augend2 == null) {
            return Coalesce.coalesce(augend1, augend2);
        }
        return augend1 + augend2;
    }

    /**
     * 整型相加
     *
     * @param augend1 加数
     * @param augend2 加数
     * @return java.lang.Integer
     * @author HuangLinWei
     * @since 2018/11/7
     */
    public static Integer add(Integer augend1, Integer augend2) {
        if (augend1 == null && augend2 == null) {
            return 0;
        }
        if (augend1 == null || augend2 == null) {
            return Coalesce.coalesce(augend1, augend2);
        }
        return augend1 + augend2;
    }

    /**
     * 整型相减
     * @author weiys
     * @since 2019/05/05 18:08
     * @param augend1 被减数
     * @param augend2 减数
     * @return java.lang.Integer       
     */
    public static Integer subtract(Integer augend1, Integer augend2) {
        return Coalesce.coalesce(augend1, 0) - Coalesce.coalesce(augend2, 0);
    }

    /**
     * 整型相减
     * @author weiys
     * @since 2019/05/05 18:08
     * @param augends 第一个值为被减数，后面都为减数
     * @return java.lang.Integer
     */
    public static Integer subtract(Integer... augends) {
        Integer result = Coalesce.coalesce(augends[0], 0) * 2;
        for (Integer augend : augends) {
            result = result - Coalesce.coalesce(augend, 0);
        }
        return result;
    }


}
